home *** CD-ROM | disk | FTP | other *** search
/ Aminet 52 / Aminet 52 (2002)(GTI - Schatztruhe)[!][Dec 2002].iso / Aminet / util / moni / Scout-src.lha / source / objects / scout_devices.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-09-17  |  17.0 KB  |  488 lines
  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28. #include "system_headers.h"
  29.  
  30. struct DeviceCallbackUserData {
  31.     APTR ud_List;
  32.     ULONG ud_Count;
  33. };
  34.  
  35. __asm __saveds LONG devlist_con2func(register __a2 Object *obj, register __a1 struct NList_ConstructMessage *msg, register __a0 struct Hook *hook)
  36. {
  37.     return AllocListEntry(msg->pool, msg->entry, sizeof(struct DeviceEntry));
  38. }
  39.  
  40. MakeHook(devlist_con2hook, devlist_con2func);
  41.  
  42. __asm __saveds LONG devlist_des2func(register __a2 Object *obj, register __a1 struct NList_DestructMessage *msg, register __a0 struct Hook *hook)
  43. {
  44.     FreeListEntry(msg->pool, &msg->entry);
  45.  
  46.     return 0;
  47. }
  48.  
  49. MakeHook(devlist_des2hook, devlist_des2func);
  50.  
  51. __asm __saveds LONG devlist_dsp2func(register __a2 Object *obj, register __a1 struct NList_DisplayMessage *msg, register __a0 struct Hook *hook)
  52. {
  53.     struct DeviceEntry *de = (struct DeviceEntry *)msg->entry;
  54.  
  55.     if (de) {
  56.         msg->strings[0] = de->de_Address;
  57.         msg->strings[1] = de->de_Name;
  58.         msg->strings[2] = de->de_Type;
  59.         msg->strings[3] = de->de_Pri;
  60.         msg->strings[4] = de->de_Version;
  61.         msg->strings[5] = de->de_OpenCount;
  62.         msg->strings[6] = de->de_RAMPtrCount;
  63.     } else {
  64.         msg->strings[0] = "Address";
  65.         msg->strings[1] = "ln_Name";
  66.         msg->strings[2] = "ln_Type";
  67.         msg->strings[3] = "ln_Pri";
  68.         msg->strings[4] = "Version";
  69.         msg->strings[5] = "OCnt";
  70.         msg->strings[6] = "RPC";
  71.         msg->preparses[0] = MUIX_B;
  72.         msg->preparses[1] = MUIX_B;
  73.         msg->preparses[2] = MUIX_B;
  74.         msg->preparses[3] = MUIX_B;
  75.         msg->preparses[4] = MUIX_B;
  76.         msg->preparses[5] = MUIX_B;
  77.         msg->preparses[6] = MUIX_B;
  78.     }
  79.  
  80.     return 0;
  81. }
  82.  
  83. MakeHook(devlist_dsp2hook, devlist_dsp2func);
  84.  
  85. static LONG devlist_cmp2colfunc( struct DeviceEntry *de1,
  86.                                  struct DeviceEntry *de2,
  87.                                  ULONG column )
  88. {
  89.     LONG pri1, pri2;
  90.  
  91.     switch (column) {
  92.         case 0: return stricmp(de1->de_Address, de2->de_Address);
  93.         case 1: return stricmp(de1->de_Name, de2->de_Name);
  94.         case 2: return stricmp(de1->de_Type, de2->de_Type);
  95.         case 3: IsDec(de1->de_Pri, &pri1); IsDec(de2->de_Pri, &pri2); return pri2 - pri1;
  96.         case 4: return stricmp(de1->de_Version, de2->de_Version);
  97.         case 5: return stricmp(de1->de_OpenCount, de2->de_OpenCount);
  98.         case 6: return stricmp(de1->de_RAMPtrCount, de2->de_RAMPtrCount);
  99.     }
  100. }
  101.  
  102. __asm __saveds LONG devlist_cmp2func(register __a2 Object *obj, register __a1 struct NList_CompareMessage *msg, register __a0 struct Hook *hook)
  103. {
  104.     LONG cmp;
  105.     struct DeviceEntry *de1, *de2;
  106.     ULONG col1, col2;
  107.  
  108.     de1 = (struct DeviceEntry *)msg->entry1;
  109.     de2 = (struct DeviceEntry *)msg->entry2;
  110.     col1 = msg->sort_type & MUIV_NList_TitleMark_ColMask;
  111.     col2 = msg->sort_type2 & MUIV_NList_TitleMark2_ColMask;
  112.  
  113.     if (msg->sort_type == MUIV_NList_SortType_None) return 0;
  114.  
  115.     if (msg->sort_type & MUIV_NList_TitleMark_TypeMask) {
  116.         cmp = devlist_cmp2colfunc(de2, de1, col1);
  117.     } else {
  118.         cmp = devlist_cmp2colfunc(de1, de2, col1);
  119.     }
  120.  
  121.     if (cmp != 0 || col1 == col2) return cmp;
  122.  
  123.     if (msg->sort_type2 & MUIV_NList_TitleMark2_TypeMask) {
  124.         cmp = devlist_cmp2colfunc(de2, de1, col2);
  125.     } else {
  126.         cmp = devlist_cmp2colfunc(de1, de2, col2);
  127.     }
  128.  
  129.     return cmp;
  130. }
  131.  
  132. MakeHook(devlist_cmp2hook, devlist_cmp2func);
  133.  
  134. void FlushDevices( void )
  135. {
  136.     struct Device *dd, *next_dd;
  137.  
  138.     Forbid();
  139.  
  140.     ITERATE_CHANGING_LIST(&SysBase->DeviceList, struct Device *, dd, next_dd) {
  141.         if (dd->dd_Library.lib_OpenCnt == 0) RemDevice(dd);
  142.     }
  143.  
  144.     Permit();
  145. }
  146.  
  147. static void ReceiveList( void (* callback)( struct DeviceEntry *de, void *userData ),
  148.                          void *userData )
  149. {
  150.     struct DeviceEntry *de;
  151.  
  152.     if (de = tbAllocVecPooled(globalPool, sizeof(struct DeviceEntry))) {
  153.         if (SendDaemon("GetDevList")) {
  154.             while (ReceiveDecodedEntry((UBYTE *)de, sizeof(struct DeviceEntry))) {
  155.                 callback(de, userData);
  156.             }
  157.         }
  158.  
  159.         tbFreeVecPooled(globalPool, de);
  160.     }
  161. }
  162.  
  163. static void IterateList( void (* callback)( struct DeviceEntry *de, void *userData ),
  164.                          void *userData )
  165. {
  166.     struct Device *dd;
  167.     struct MinList tmplist;
  168.     struct DeviceEntry *de, *_de;
  169.  
  170.     NewList((struct List *)&tmplist);
  171.  
  172.     Forbid();
  173.  
  174.     ITERATE_LIST(&SysBase->DeviceList, struct Device *, dd) {
  175.         if (de = AllocVec(sizeof(struct DeviceEntry), MEMF_PUBLIC)) {
  176.             ULONG cnt;
  177.  
  178.             de->de_Addr = dd;
  179.  
  180.             _snprintf(de->de_Address, sizeof(de->de_Address), "$%08lx", dd);
  181.             stccpy(de->de_Name, dd->dd_Library.lib_Node.ln_Name, sizeof(de->de_Name));
  182.             _snprintf(de->de_Pri, sizeof(de->de_Pri), "%4ld", dd->dd_Library.lib_Node.ln_Pri);
  183.             _snprintf(de->de_Version, sizeof(de->de_Version), "%ld.%ld", dd->dd_Library.lib_Version, dd->dd_Library.lib_Revision);
  184.             _snprintf(de->de_OpenCount, sizeof(de->de_OpenCount), "%6lD", dd->dd_Library.lib_OpenCnt);
  185.  
  186.             cnt = GetRamPointerCount(&dd->dd_Library);
  187.             if (cnt == (dd->dd_Library.lib_NegSize / LIB_VECTSIZE)) {
  188.                 stccpy(de->de_RAMPtrCount, "***", sizeof(de->de_RAMPtrCount));
  189.             } else {
  190.                 _snprintf(de->de_RAMPtrCount, sizeof(de->de_RAMPtrCount), "%4lD", cnt);
  191.             }
  192.  
  193.             stccpy(de->de_Type, GetNodeType(dd->dd_Library.lib_Node.ln_Type), sizeof(de->de_Type));
  194.  
  195.             AddTail((struct List *)&tmplist, (struct Node *)de);
  196.         }
  197.     }
  198.  
  199.     Permit();
  200.  
  201.     ITERATE_CHANGING_LIST(&tmplist, struct DeviceEntry *, de, _de) {
  202.         callback(de, userData);
  203.         FreeVec(de);
  204.     }
  205. }
  206.  
  207. static void UpdateCallback( struct DeviceEntry *de,
  208.                             void *userData )
  209. {
  210.     struct DeviceCallbackUserData *ud = (struct DeviceCallbackUserData *)userData;
  211.  
  212.     InsertSortedEntry(ud->ud_List, de);
  213.     ud->ud_Count++;
  214. }
  215.  
  216. static void PrintCallback( struct DeviceEntry *de,
  217.                            void *userData )
  218. {
  219.     PrintFOneLine((BPTR)userData, " %s %4s %4s %4s %s %s\n", de->de_Address, de->de_Pri, de->de_OpenCount, de->de_RAMPtrCount, de->de_Name, de->de_Version);
  220. }
  221.  
  222. static void SendCallback( struct DeviceEntry *de,
  223.                           void *userData )
  224. {
  225.     SendEncodedEntry((UBYTE *)de, sizeof(struct DeviceEntry));
  226. }
  227.  
  228. static ULONG __saveds mNew( struct IClass *cl,
  229.                             Object *obj,
  230.                             struct opSet *msg )
  231. {
  232.     APTR devlist, devtext, devcount, updateButton, printButton, removeButton, priorityButton, moreButton, funcButton, exitButton;
  233.  
  234.     if (obj = (Object *)DoSuperNew(cl, obj,
  235.         MUIA_HelpNode, DevicesText,
  236.         MUIA_Window_ID, MakeID('D','E','V','S'),
  237.         WindowContents, VGroup,
  238.  
  239.             Child, devlist = MyNListviewObject(MakeID('D','E','L','V'), "BAR,BAR,BAR P=" MUIX_C ",BAR P=" MUIX_R ",BAR P=" MUIX_C ",BAR P=" MUIX_R ",BAR P=" MUIX_R, &devlist_con2hook, &devlist_des2hook, &devlist_dsp2hook, &devlist_cmp2hook, TRUE),
  240.             Child, MyBelowListview(&devtext, &devcount),
  241.  
  242.             Child, MyVSpace(4),
  243.  
  244.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  245.                 Child, priorityButton = MakeButton(txtPriority),
  246.                 Child, removeButton   = MakeButton(txtRemove),
  247.                 Child, funcButton     = MakeButton(txtFunctions),
  248.             End,
  249.  
  250.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  251.                 Child, updateButton   = MakeButton(txtUpdate),
  252.                 Child, printButton    = MakeButton(txtPrint),
  253.                 Child, moreButton     = MakeButton(txtMore),
  254.                 Child, exitButton     = MakeButton(txtExit),
  255.             End,
  256.         End,
  257.         TAG_MORE, msg->ops_AttrList))
  258.     {
  259.         struct DevicesWinData *dwd = INST_DATA(cl, obj);
  260.         APTR parent;
  261.  
  262.         dwd->dwd_DeviceList = devlist;
  263.         dwd->dwd_DeviceText = devtext;
  264.         dwd->dwd_DeviceCount = devcount;
  265.         dwd->dwd_RemoveButton = removeButton;
  266.         dwd->dwd_PriorityButton = priorityButton;
  267.         dwd->dwd_MoreButton = moreButton;
  268.         dwd->dwd_FunctionsButton = funcButton;
  269.  
  270.         parent = (APTR)GetTagData(MUIA_Window_ParentWindow, (ULONG)NULL, msg->ops_AttrList);
  271.  
  272.         set(obj, MUIA_Window_Title, MyGetWindowTitle("DEVICES", dwd->dwd_Title, sizeof(dwd->dwd_Title)));
  273.         set(obj, MUIA_Window_ActiveObject, devlist);
  274.         set(removeButton, MUIA_Disabled, TRUE);
  275.         set(priorityButton, MUIA_Disabled, TRUE);
  276.         set(moreButton, MUIA_Disabled, TRUE);
  277.         set(funcButton, MUIA_Disabled, TRUE);
  278.  
  279.         DoMethod(parent,          MUIM_Window_AddChildWindow, obj);
  280.         DoMethod(obj,             MUIM_Notify, MUIA_Window_CloseRequest, TRUE,           MUIV_Notify_Application, 5, MUIM_Application_PushMethod, parent, 2, MUIM_Window_RemChildWindow, obj);
  281.         DoMethod(devlist,         MUIM_Notify, MUIA_NList_Active,        MUIV_EveryTime, obj,                     1, MUIM_DevicesWin_ListChange);
  282.         DoMethod(devlist,         MUIM_Notify, MUIA_NList_DoubleClick,   MUIV_EveryTime, obj,                     1, MUIM_DevicesWin_More);
  283.         DoMethod(updateButton,    MUIM_Notify, MUIA_Pressed,             FALSE,          obj,                     1, MUIM_DevicesWin_Update);
  284.         DoMethod(printButton,     MUIM_Notify, MUIA_Pressed,             FALSE,          obj,                     1, MUIM_DevicesWin_Print);
  285.         DoMethod(removeButton,    MUIM_Notify, MUIA_Pressed,             FALSE,          obj,                     1, MUIM_DevicesWin_Remove);
  286.         DoMethod(moreButton,      MUIM_Notify, MUIA_Pressed,             FALSE,          obj,                     1, MUIM_DevicesWin_More);
  287.         DoMethod(priorityButton,  MUIM_Notify, MUIA_Pressed,             FALSE,          obj,                     1, MUIM_DevicesWin_Priority);
  288.         DoMethod(funcButton,      MUIM_Notify, MUIA_Pressed,             FALSE,          obj,                     1, MUIM_DevicesWin_Functions);
  289.         DoMethod(exitButton,      MUIM_Notify, MUIA_Pressed,             FALSE,          obj,                     3, MUIM_Set, MUIA_Window_CloseRequest, TRUE);
  290.         DoMethod(devlist,         MUIM_NList_Sort3, MUIV_NList_Sort3_SortType_1, MUIV_NList_SortTypeAdd_None, MUIV_NList_Sort3_SortType_Both);
  291.     }
  292.  
  293.     return (ULONG)obj;
  294. }
  295.  
  296. static ULONG __saveds mDispose( struct IClass *cl,
  297.                                 Object *obj,
  298.                                 struct opSet *msg )
  299. {
  300.     struct DevicesWinData *dwd = INST_DATA(cl, obj);
  301.  
  302.     set(obj, MUIA_Window_Open, FALSE);
  303.     DoMethod(dwd->dwd_DeviceList, MUIM_NList_Clear);
  304.  
  305.     return (DoSuperMethodA(cl, obj, msg));
  306. }
  307.  
  308. static ULONG __saveds mUpdate( struct IClass *cl,
  309.                                Object *obj,
  310.                                Msg msg )
  311. {
  312.     struct DevicesWinData *dwd = INST_DATA(cl, obj);
  313.     struct DeviceCallbackUserData ud;
  314.  
  315.     ApplicationSleep(TRUE);
  316.     set(dwd->dwd_DeviceList, MUIA_NList_Quiet, TRUE);
  317.     DoMethod(dwd->dwd_DeviceList, MUIM_NList_Clear);
  318.  
  319.     ud.ud_List = dwd->dwd_DeviceList;
  320.     ud.ud_Count = 0;
  321.  
  322.     if (clientstate) {
  323.         ReceiveList(UpdateCallback, &ud);
  324.     } else {
  325.         IterateList(UpdateCallback, &ud);
  326.     }
  327.  
  328.     SetCountText(dwd->dwd_DeviceCount, ud.ud_Count);
  329.     MySetContents(dwd->dwd_DeviceText, "");
  330.  
  331.     set(dwd->dwd_DeviceList, MUIA_NList_Quiet, FALSE);
  332.     set(dwd->dwd_PriorityButton, MUIA_Disabled, TRUE);
  333.     set(dwd->dwd_RemoveButton, MUIA_Disabled, TRUE);
  334.     set(dwd->dwd_MoreButton, MUIA_Disabled, TRUE);
  335.     set(dwd->dwd_FunctionsButton, MUIA_Disabled, TRUE);
  336.     ApplicationSleep(FALSE);
  337.  
  338.     return 0;
  339. }
  340.  
  341. static ULONG __saveds mPrint( struct IClass *cl,
  342.                               Object *obj,
  343.                               Msg msg )
  344. {
  345.     PrintDevices(NULL);
  346.  
  347.     return 0;
  348. }
  349.  
  350. static ULONG __saveds mRemove( struct IClass *cl,
  351.                                Object *obj,
  352.                                Msg msg )
  353. {
  354.     struct DevicesWinData *dwd = INST_DATA(cl, obj);
  355.     struct DeviceEntry *de;
  356.  
  357.     if (de = (struct DeviceEntry *)GetActiveEntry(dwd->dwd_DeviceList)) {
  358.         if (MyRequest(msgYesNo, msgWantToRemoveDevice, de->de_Name)) {
  359.             MyDoCommand("RemoveDevice \"%s\"", de->de_Name);
  360.             DoMethod(obj, MUIM_DevicesWin_Update);
  361.         }
  362.     }
  363.  
  364.     return 0;
  365. }
  366.  
  367. static ULONG __saveds mPriority( struct IClass *cl,
  368.                                  Object *obj,
  369.                                  Msg msg )
  370. {
  371.     struct DevicesWinData *dwd = INST_DATA(cl, obj);
  372.     struct DeviceEntry *de;
  373.  
  374.     if (de = (struct DeviceEntry *)GetActiveEntry(dwd->dwd_DeviceList)) {
  375.         LONG pri;
  376.  
  377.         pri = atol(de->de_Pri);
  378.         if (GetPriority(de->de_Name, &pri)) {
  379.             if (MyDoCommand("SetPriority DEVICE \"%s\" %ld", de->de_Name, pri)) {
  380.                 _snprintf(de->de_Pri, sizeof(de->de_Pri), "%4ld", pri);
  381.                 RedrawActiveEntry(dwd->dwd_DeviceList);
  382.             }
  383.         }
  384.     }
  385.  
  386.     return 0;
  387. }
  388.  
  389. static ULONG __saveds mMore( struct IClass *cl,
  390.                              Object *obj,
  391.                              Msg msg )
  392. {
  393.     struct DevicesWinData *dwd = INST_DATA(cl, obj);
  394.     struct DeviceEntry *de;
  395.  
  396.     if (de = (struct DeviceEntry *)GetActiveEntry(dwd->dwd_DeviceList)) {
  397.         APTR detailWin;
  398.  
  399.         if (detailWin = DevicesDetailWindowObject,
  400.                 MUIA_Window_Title, de->de_Name,
  401.                 MUIA_Window_ParentWindow, obj,
  402.                 MUIA_Window_MaxChildWindowCount, (opts.SingleWindows) ? 1 : 0,
  403.             End) {
  404.             set(detailWin, MUIA_DevicesDetailWin_Device, de);
  405.             set(detailWin, MUIA_Window_Open, TRUE);
  406.         }
  407.     }
  408.  
  409.     return 0;
  410. }
  411.  
  412. static ULONG __saveds mFunctions( struct IClass *cl,
  413.                                   Object *obj,
  414.                                   Msg msg )
  415. {
  416.     struct DevicesWinData *dwd = INST_DATA(cl, obj);
  417.     struct DeviceEntry *de;
  418.  
  419.     if (de = (struct DeviceEntry *)GetActiveEntry(dwd->dwd_DeviceList)) {
  420.         APTR funcWin;
  421.  
  422.         if (funcWin = FunctionsWindowObject,
  423.                 MUIA_Window_ParentWindow, obj,
  424.             End) {
  425.             DoMethod(funcWin, MUIM_FunctionsWin_ShowFunctions, MUIV_FunctionsWin_NodeType_Device, de->de_Addr, de->de_Name);
  426.         }
  427.     }
  428.  
  429.     return 0;
  430. }
  431.  
  432. static ULONG __saveds mListChange( struct IClass *cl,
  433.                                    Object *obj,
  434.                                    Msg msg )
  435. {
  436.     struct DevicesWinData *dwd = INST_DATA(cl, obj);
  437.     struct DeviceEntry *de;
  438.  
  439.     if (de = (struct DeviceEntry *)GetActiveEntry(dwd->dwd_DeviceList)) {
  440.         MySetContents(dwd->dwd_DeviceText, "%s \"%s\"", de->de_Address, de->de_Name);
  441.         set(dwd->dwd_PriorityButton, MUIA_Disabled, FALSE);
  442.         set(dwd->dwd_RemoveButton, MUIA_Disabled, FALSE);
  443.         if (!clientstate) {
  444.             set(dwd->dwd_MoreButton, MUIA_Disabled, FALSE);
  445.             set(dwd->dwd_FunctionsButton, MUIA_Disabled, FALSE);
  446.         }
  447.     }
  448.  
  449.     return 0;
  450. }
  451.  
  452. ULONG __asm __saveds DevicesWinDispatcher( register __a0 struct IClass *cl,
  453.                                            register __a2 Object *obj,
  454.                                            register __a1 Msg msg )
  455. {
  456.     switch (msg->MethodID) {
  457.         case OM_NEW:                     return (mNew(cl, obj, (APTR)msg));
  458.         case OM_DISPOSE:                 return (mDispose(cl, obj, (APTR)msg));
  459.         case MUIM_DevicesWin_Update:     return (mUpdate(cl, obj, (APTR)msg));
  460.         case MUIM_DevicesWin_Print:      return (mPrint(cl, obj, (APTR)msg));
  461.         case MUIM_DevicesWin_Remove:     return (mRemove(cl, obj, (APTR)msg));
  462.         case MUIM_DevicesWin_Priority:   return (mPriority(cl, obj, (APTR)msg));
  463.         case MUIM_DevicesWin_More:       return (mMore(cl, obj, (APTR)msg));
  464.         case MUIM_DevicesWin_Functions:  return (mFunctions(cl, obj, (APTR)msg));
  465.         case MUIM_DevicesWin_ListChange: return (mListChange(cl, obj, (APTR)msg));
  466.     }
  467.  
  468.     return (DoSuperMethodA(cl, obj, msg));
  469. }
  470.  
  471. void PrintDevices( char *filename )
  472. {
  473.     BPTR handle;
  474.  
  475.     if (handle = HandlePrintStart(filename)) {
  476.         PrintFOneLine(handle, "\n  Address   Pri  OpenC  RPC Name & Version\n\n");
  477.         IterateList(PrintCallback, (void *)handle);
  478.     }
  479.  
  480.     HandlePrintStop();
  481. }
  482.  
  483. void SendDevList( void )
  484. {
  485.     IterateList(SendCallback, NULL);
  486. }
  487.  
  488.